home *** CD-ROM | disk | FTP | other *** search
/ Chip: 2001 Haziran / CHIP Haziran2001.iso / prog / share / 17 / dings_e.exe / Compiler / Include / stl_iterator.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-03-08  |  25.6 KB  |  844 lines
  1. /*
  2.  *
  3.  * Copyright (c) 1994
  4.  * Hewlett-Packard Company
  5.  *
  6.  * Permission to use, copy, modify, distribute and sell this software
  7.  * and its documentation for any purpose is hereby granted without fee,
  8.  * provided that the above copyright notice appear in all copies and
  9.  * that both that copyright notice and this permission notice appear
  10.  * in supporting documentation.  Hewlett-Packard Company makes no
  11.  * representations about the suitability of this software for any
  12.  * purpose.  It is provided "as is" without express or implied warranty.
  13.  *
  14.  *
  15.  * Copyright (c) 1996,1997
  16.  * Silicon Graphics Computer Systems, Inc.
  17.  *
  18.  * Permission to use, copy, modify, distribute and sell this software
  19.  * and its documentation for any purpose is hereby granted without fee,
  20.  * provided that the above copyright notice appear in all copies and
  21.  * that both that copyright notice and this permission notice appear
  22.  * in supporting documentation.  Silicon Graphics makes no
  23.  * representations about the suitability of this software for any
  24.  * purpose.  It is provided "as is" without express or implied warranty.
  25.  */
  26.  
  27. /* NOTE: This is an internal header file, included by other STL headers.
  28.  *   You should not attempt to use it directly.
  29.  */
  30.  
  31. #ifndef __SGI_STL_INTERNAL_ITERATOR_H
  32. #define __SGI_STL_INTERNAL_ITERATOR_H
  33.  
  34. __STL_BEGIN_NAMESPACE
  35.  
  36. struct input_iterator_tag {};
  37. struct output_iterator_tag {};
  38. struct forward_iterator_tag : public input_iterator_tag {};
  39. struct bidirectional_iterator_tag : public forward_iterator_tag {};
  40. struct random_access_iterator_tag : public bidirectional_iterator_tag {};
  41.  
  42. template <class T, class Distance> struct input_iterator {
  43.   typedef input_iterator_tag iterator_category;
  44.   typedef T                  value_type;
  45.   typedef Distance           difference_type;
  46.   typedef T*                 pointer;
  47.   typedef T&                 reference;
  48. };
  49.  
  50. struct output_iterator {
  51.   typedef output_iterator_tag iterator_category;
  52.   typedef void                value_type;
  53.   typedef void                difference_type;
  54.   typedef void                pointer;
  55.   typedef void                reference;
  56. };
  57.  
  58. template <class T, class Distance> struct forward_iterator {
  59.   typedef forward_iterator_tag iterator_category;
  60.   typedef T                    value_type;
  61.   typedef Distance             difference_type;
  62.   typedef T*                   pointer;
  63.   typedef T&                   reference;
  64. };
  65.  
  66.  
  67. template <class T, class Distance> struct bidirectional_iterator {
  68.   typedef bidirectional_iterator_tag iterator_category;
  69.   typedef T                          value_type;
  70.   typedef Distance                   difference_type;
  71.   typedef T*                         pointer;
  72.   typedef T&                         reference;
  73. };
  74.  
  75. template <class T, class Distance> struct random_access_iterator {
  76.   typedef random_access_iterator_tag iterator_category;
  77.   typedef T                          value_type;
  78.   typedef Distance                   difference_type;
  79.   typedef T*                         pointer;
  80.   typedef T&                         reference;
  81. };
  82.  
  83. #ifdef __STL_USE_NAMESPACES
  84. template <class Category, class T, class Distance = ptrdiff_t,
  85.           class Pointer = T*, class Reference = T&>
  86. struct iterator {
  87.   typedef Category  iterator_category;
  88.   typedef T         value_type;
  89.   typedef Distance  difference_type;
  90.   typedef Pointer   pointer;
  91.   typedef Reference reference;
  92. };
  93. #endif /* __STL_USE_NAMESPACES */
  94.  
  95. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  96.  
  97. template <class Iterator>
  98. struct iterator_traits {
  99.   typedef typename Iterator::iterator_category iterator_category;
  100.   typedef typename Iterator::value_type        value_type;
  101.   typedef typename Iterator::difference_type   difference_type;
  102.   typedef typename Iterator::pointer           pointer;
  103.   typedef typename Iterator::reference         reference;
  104. };
  105.  
  106. template <class T>
  107. struct iterator_traits<T*> {
  108.   typedef random_access_iterator_tag iterator_category;
  109.   typedef T                          value_type;
  110.   typedef ptrdiff_t                  difference_type;
  111.   typedef T*                         pointer;
  112.   typedef T&                         reference;
  113. };
  114.  
  115. template <class T>
  116. struct iterator_traits<const T*> {
  117.   typedef random_access_iterator_tag iterator_category;
  118.   typedef T                          value_type;
  119.   typedef ptrdiff_t                  difference_type;
  120.   typedef const T*                   pointer;
  121.   typedef const T&                   reference;
  122. };
  123.  
  124. template <class Iterator>
  125. inline typename iterator_traits<Iterator>::iterator_category
  126. iterator_category(const Iterator&) {
  127.   typedef typename iterator_traits<Iterator>::iterator_category category;
  128.   return category();
  129. }
  130.  
  131. template <class Iterator>
  132. inline typename iterator_traits<Iterator>::difference_type*
  133. distance_type(const Iterator&) {
  134.   return static_cast<typename iterator_traits<Iterator>::difference_type*>(0);
  135. }
  136.  
  137. template <class Iterator>
  138. inline typename iterator_traits<Iterator>::value_type*
  139. value_type(const Iterator&) {
  140.   return static_cast<typename iterator_traits<Iterator>::value_type*>(0);
  141. }
  142.  
  143. #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  144.  
  145. template <class T, class Distance> 
  146. inline input_iterator_tag 
  147. iterator_category(const input_iterator<T, Distance>&) {
  148.   return input_iterator_tag();
  149. }
  150.  
  151. inline output_iterator_tag iterator_category(const output_iterator&) {
  152.   return output_iterator_tag();
  153. }
  154.  
  155. template <class T, class Distance> 
  156. inline forward_iterator_tag
  157. iterator_category(const forward_iterator<T, Distance>&) {
  158.   return forward_iterator_tag();
  159. }
  160.  
  161. template <class T, class Distance> 
  162. inline bidirectional_iterator_tag
  163. iterator_category(const bidirectional_iterator<T, Distance>&) {
  164.   return bidirectional_iterator_tag();
  165. }
  166.  
  167. template <class T, class Distance> 
  168. inline random_access_iterator_tag
  169. iterator_category(const random_access_iterator<T, Distance>&) {
  170.   return random_access_iterator_tag();
  171. }
  172.  
  173. template <class T>
  174. inline random_access_iterator_tag iterator_category(const T*) {
  175.   return random_access_iterator_tag();
  176. }
  177.  
  178. template <class T, class Distance> 
  179. inline T* value_type(const input_iterator<T, Distance>&) {
  180.   return (T*)(0); 
  181. }
  182.  
  183. template <class T, class Distance> 
  184. inline T* value_type(const forward_iterator<T, Distance>&) {
  185.   return (T*)(0);
  186. }
  187.  
  188. template <class T, class Distance> 
  189. inline T* value_type(const bidirectional_iterator<T, Distance>&) {
  190.   return (T*)(0);
  191. }
  192.  
  193. template <class T, class Distance> 
  194. inline T* value_type(const random_access_iterator<T, Distance>&) {
  195.   return (T*)(0);
  196. }
  197.  
  198. template <class T>
  199. inline T* value_type(const T*) { return (T*)(0); }
  200.  
  201. template <class T, class Distance> 
  202. inline Distance* distance_type(const input_iterator<T, Distance>&) {
  203.   return (Distance*)(0);
  204. }
  205.  
  206. template <class T, class Distance> 
  207. inline Distance* distance_type(const forward_iterator<T, Distance>&) {
  208.   return (Distance*)(0);
  209. }
  210.  
  211. template <class T, class Distance> 
  212. inline Distance* 
  213. distance_type(const bidirectional_iterator<T, Distance>&) {
  214.   return (Distance*)(0);
  215. }
  216.  
  217. template <class T, class Distance> 
  218. inline Distance* 
  219. distance_type(const random_access_iterator<T, Distance>&) {
  220.   return (Distance*)(0);
  221. }
  222.  
  223. template <class T>
  224. inline ptrdiff_t* distance_type(const T*) { return (ptrdiff_t*)(0); }
  225.  
  226. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  227.  
  228. template <class InputIterator, class Distance>
  229. inline void __distance(InputIterator first, InputIterator last, Distance& n, 
  230.                        input_iterator_tag) {
  231.   while (first != last) { ++first; ++n; }
  232. }
  233.  
  234. template <class RandomAccessIterator, class Distance>
  235. inline void __distance(RandomAccessIterator first, RandomAccessIterator last, 
  236.                        Distance& n, random_access_iterator_tag) {
  237.   n += last - first;
  238. }
  239.  
  240. template <class InputIterator, class Distance>
  241. inline void distance(InputIterator first, InputIterator last, Distance& n) {
  242.   __distance(first, last, n, iterator_category(first));
  243. }
  244.  
  245. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  246.  
  247. template <class InputIterator>
  248. inline iterator_traits<InputIterator>::difference_type
  249. __distance(InputIterator first, InputIterator last, input_iterator_tag) {
  250.   iterator_traits<InputIterator>::difference_type n = 0;
  251.   while (first != last) {
  252.     ++first; ++n;
  253.   }
  254.   return n;
  255. }
  256.  
  257. template <class RandomAccessIterator>
  258. inline iterator_traits<RandomAccessIterator>::difference_type
  259. __distance(RandomAccessIterator first, RandomAccessIterator last,
  260.            random_access_iterator_tag) {
  261.   return last - first;
  262. }
  263.  
  264. template <class InputIterator>
  265. inline iterator_traits<InputIterator>::difference_type
  266. distance(InputIterator first, InputIterator last) {
  267.   typedef typename iterator_traits<InputIterator>::iterator_category category;
  268.   return __distance(first, last, category());
  269. }
  270.  
  271. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  272.  
  273. template <class InputIterator, class Distance>
  274. inline void __advance(InputIterator& i, Distance n, input_iterator_tag) {
  275.   while (n--) ++i;
  276. }
  277.  
  278. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  279. #pragma set woff 1183
  280. #endif
  281.  
  282. template <class BidirectionalIterator, class Distance>
  283. inline void __advance(BidirectionalIterator& i, Distance n, 
  284.                       bidirectional_iterator_tag) {
  285.   if (n >= 0)
  286.     while (n--) ++i;
  287.   else
  288.     while (n++) --i;
  289. }
  290.  
  291. #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32)
  292. #pragma reset woff 1183
  293. #endif
  294.  
  295. template <class RandomAccessIterator, class Distance>
  296. inline void __advance(RandomAccessIterator& i, Distance n, 
  297.                       random_access_iterator_tag) {
  298.   i += n;
  299. }
  300.  
  301. template <class InputIterator, class Distance>
  302. inline void advance(InputIterator& i, Distance n) {
  303.   __advance(i, n, iterator_category(i));
  304. }
  305.  
  306. template <class Container>
  307. class back_insert_iterator {
  308. protected:
  309.   Container* container;
  310. public:
  311.   typedef output_iterator_tag iterator_category;
  312.   typedef void                value_type;
  313.   typedef void                difference_type;
  314.   typedef void                pointer;
  315.   typedef void                reference;
  316.  
  317.   explicit back_insert_iterator(Container& x) : container(&x) {}
  318.   back_insert_iterator<Container>&
  319.   operator=(const typename Container::value_type& value) { 
  320.     container->push_back(value);
  321.     return *this;
  322.   }
  323.   back_insert_iterator<Container>& operator*() { return *this; }
  324.   back_insert_iterator<Container>& operator++() { return *this; }
  325.   back_insert_iterator<Container>& operator++(int) { return *this; }
  326. };
  327.  
  328. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  329.  
  330. template <class Container>
  331. inline output_iterator_tag
  332. iterator_category(const back_insert_iterator<Container>&)
  333. {
  334.   return output_iterator_tag();
  335. }
  336.  
  337. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  338.  
  339. template <class Container>
  340. inline back_insert_iterator<Container> back_inserter(Container& x) {
  341.   return back_insert_iterator<Container>(x);
  342. }
  343.  
  344. template <class Container>
  345. class front_insert_iterator {
  346. protected:
  347.   Container* container;
  348. public:
  349.   typedef output_iterator_tag iterator_category;
  350.   typedef void                value_type;
  351.   typedef void                difference_type;
  352.   typedef void                pointer;
  353.   typedef void                reference;
  354.  
  355.   explicit front_insert_iterator(Container& x) : container(&x) {}
  356.   front_insert_iterator<Container>&
  357.   operator=(const typename Container::value_type& value) { 
  358.     container->push_front(value);
  359.     return *this;
  360.   }
  361.   front_insert_iterator<Container>& operator*() { return *this; }
  362.   front_insert_iterator<Container>& operator++() { return *this; }
  363.   front_insert_iterator<Container>& operator++(int) { return *this; }
  364. };
  365.  
  366. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  367.  
  368. template <class Container>
  369. inline output_iterator_tag
  370. iterator_category(const front_insert_iterator<Container>&)
  371. {
  372.   return output_iterator_tag();
  373. }
  374.  
  375. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  376.  
  377. template <class Container>
  378. inline front_insert_iterator<Container> front_inserter(Container& x) {
  379.   return front_insert_iterator<Container>(x);
  380. }
  381.  
  382. template <class Container>
  383. class insert_iterator {
  384. protected:
  385.   Container* container;
  386.   typename Container::iterator iter;
  387. public:
  388.   typedef output_iterator_tag iterator_category;
  389.   typedef void                value_type;
  390.   typedef void                difference_type;
  391.   typedef void                pointer;
  392.   typedef void                reference;
  393.  
  394.   insert_iterator(Container& x, typename Container::iterator i) 
  395.     : container(&x), iter(i) {}
  396.   insert_iterator<Container>&
  397.   operator=(const typename Container::value_type& value) { 
  398.     iter = container->insert(iter, value);
  399.     ++iter;
  400.     return *this;
  401.   }
  402.   insert_iterator<Container>& operator*() { return *this; }
  403.   insert_iterator<Container>& operator++() { return *this; }
  404.   insert_iterator<Container>& operator++(int) { return *this; }
  405. };
  406.  
  407. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  408.  
  409. template <class Container>
  410. inline output_iterator_tag
  411. iterator_category(const insert_iterator<Container>&)
  412. {
  413.   return output_iterator_tag();
  414. }
  415.  
  416. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  417.  
  418. template <class Container, class Iterator>
  419. inline insert_iterator<Container> inserter(Container& x, Iterator i) {
  420.   typedef typename Container::iterator iter;
  421.   return insert_iterator<Container>(x, iter(i));
  422. }
  423.  
  424. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  425. template <class BidirectionalIterator, class T, class Reference = T&, 
  426.           class Distance = ptrdiff_t> 
  427. #else
  428. template <class BidirectionalIterator, class T, class Reference, 
  429.           class Distance> 
  430. #endif
  431. class reverse_bidirectional_iterator {
  432.   typedef reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  433.                                          Distance> self;
  434. protected:
  435.   BidirectionalIterator current;
  436. public:
  437.   typedef bidirectional_iterator_tag iterator_category;
  438.   typedef T                          value_type;
  439.   typedef Distance                   difference_type;
  440.   typedef T*                         pointer;
  441.   typedef Reference                  reference;
  442.  
  443.   reverse_bidirectional_iterator() {}
  444.   explicit reverse_bidirectional_iterator(BidirectionalIterator x)
  445.     : current(x) {}
  446.   BidirectionalIterator base() const { return current; }
  447.   Reference operator*() const {
  448.     BidirectionalIterator tmp = current;
  449.     return *--tmp;
  450.   }
  451. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  452.   pointer operator->() const { return &(operator*()); }
  453. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  454.   self& operator++() {
  455.     --current;
  456.     return *this;
  457.   }
  458.   self operator++(int) {
  459.     self tmp = *this;
  460.     --current;
  461.     return tmp;
  462.   }
  463.   self& operator--() {
  464.     ++current;
  465.     return *this;
  466.   }
  467.   self operator--(int) {
  468.     self tmp = *this;
  469.     ++current;
  470.     return tmp;
  471.   }
  472. };
  473.  
  474. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  475.  
  476. template <class BidirectionalIterator, class T, class Reference, 
  477.           class Distance>
  478. inline bidirectional_iterator_tag
  479. iterator_category(const reverse_bidirectional_iterator<BidirectionalIterator,
  480.                                                        T,
  481.                                                        Reference, Distance>&) {
  482.   return bidirectional_iterator_tag();
  483. }
  484.  
  485. template <class BidirectionalIterator, class T, class Reference, 
  486.           class Distance>
  487. inline T*
  488. value_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
  489.                                                Reference, Distance>&) {
  490.   return (T*) 0;
  491. }
  492.  
  493. template <class BidirectionalIterator, class T, class Reference, 
  494.           class Distance>
  495. inline Distance*
  496. distance_type(const reverse_bidirectional_iterator<BidirectionalIterator, T,
  497.                                                   Reference, Distance>&) {
  498.   return (Distance*) 0;
  499. }
  500.  
  501. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  502.  
  503. template <class BidirectionalIterator, class T, class Reference,
  504.           class Distance>
  505. inline bool operator==(
  506.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  507.                                          Distance>& x, 
  508.     const reverse_bidirectional_iterator<BidirectionalIterator, T, Reference,
  509.                                          Distance>& y) {
  510.   return x.base() == y.base();
  511. }
  512.  
  513. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  514.  
  515. // This is the new version of reverse_iterator, as defined in the
  516. //  draft C++ standard.  It relies on the iterator_traits template,
  517. //  which in turn relies on partial specialization.  The class
  518. //  reverse_bidirectional_iterator is no longer part of the draft
  519. //  standard, but it is retained for backward compatibility.
  520.  
  521. template <class Iterator>
  522. class reverse_iterator 
  523. {
  524. protected:
  525.   Iterator current;
  526. public:
  527.   typedef typename iterator_traits<Iterator>::iterator_category
  528.           iterator_category;
  529.   typedef typename iterator_traits<Iterator>::value_type
  530.           value_type;
  531.   typedef typename iterator_traits<Iterator>::difference_type
  532.           difference_type;
  533.   typedef typename iterator_traits<Iterator>::pointer
  534.           pointer;
  535.   typedef typename iterator_traits<Iterator>::reference
  536.           reference;
  537.  
  538.   typedef Iterator iterator_type;
  539.   typedef reverse_iterator<Iterator> self;
  540.  
  541. public:
  542.   reverse_iterator() {}
  543.   explicit reverse_iterator(iterator_type x) : current(x) {}
  544.  
  545.   reverse_iterator(const self& x) : current(x.current) {}
  546. #ifdef __STL_MEMBER_TEMPLATES
  547.   template <class Iter>
  548.   reverse_iterator(const reverse_iterator<Iter>& x) : current(x.current) {}
  549. #endif /* __STL_MEMBER_TEMPLATES */
  550.     
  551.   iterator_type base() const { return current; }
  552.   reference operator*() const {
  553.     Iterator tmp = current;
  554.     return *--tmp;
  555.   }
  556. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  557.   pointer operator->() const { return &(operator*()); }
  558. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  559.  
  560.   self& operator++() {
  561.     --current;
  562.     return *this;
  563.   }
  564.   self operator++(int) {
  565.     self tmp = *this;
  566.     --current;
  567.     return tmp;
  568.   }
  569.   self& operator--() {
  570.     ++current;
  571.     return *this;
  572.   }
  573.   self operator--(int) {
  574.     self tmp = *this;
  575.     ++current;
  576.     return tmp;
  577.   }
  578.  
  579.   self operator+(difference_type n) const {
  580.     return self(current - n);
  581.   }
  582.   self& operator+=(difference_type n) {
  583.     current -= n;
  584.     return *this;
  585.   }
  586.   self operator-(difference_type n) const {
  587.     return self(current + n);
  588.   }
  589.   self& operator-=(difference_type n) {
  590.     current += n;
  591.     return *this;
  592.   }
  593.   reference operator[](difference_type n) const { return *(*this + n); }  
  594. }; 
  595.  
  596. template <class Iterator>
  597. inline bool operator==(const reverse_iterator<Iterator>& x, 
  598.                        const reverse_iterator<Iterator>& y) {
  599.   return x.base() == y.base();
  600. }
  601.  
  602. template <class Iterator>
  603. inline bool operator<(const reverse_iterator<Iterator>& x, 
  604.                       const reverse_iterator<Iterator>& y) {
  605.   return y.base() < x.base();
  606. }
  607.  
  608. template <class Iterator>
  609. inline typename reverse_iterator<Iterator>::difference_type
  610. operator-(const reverse_iterator<Iterator>& x, 
  611.           const reverse_iterator<Iterator>& y) {
  612.   return y.base() - x.base();
  613. }
  614.  
  615. template <class Iterator>
  616. inline reverse_iterator<Iterator> 
  617. operator+(reverse_iterator<Iterator>::difference_type n,
  618.           const reverse_iterator<Iterator>& x) {
  619.   return reverse_iterator<Iterator>(x.base() - n);
  620. }
  621.  
  622. #else /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  623.  
  624. // This is the old version of reverse_iterator, as found in the original
  625. //  HP STL.  It does not use partial specialization.
  626.  
  627. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  628. template <class RandomAccessIterator, class T, class Reference = T&,
  629.           class Distance = ptrdiff_t> 
  630. #else
  631. template <class RandomAccessIterator, class T, class Reference,
  632.           class Distance> 
  633. #endif
  634. class reverse_iterator {
  635.   typedef reverse_iterator<RandomAccessIterator, T, Reference, Distance>
  636.         self;
  637. protected:
  638.   RandomAccessIterator current;
  639. public:
  640.   typedef random_access_iterator_tag iterator_category;
  641.   typedef T                          value_type;
  642.   typedef Distance                   difference_type;
  643.   typedef T*                         pointer;
  644.   typedef Reference                  reference;
  645.  
  646.   reverse_iterator() {}
  647.   explicit reverse_iterator(RandomAccessIterator x) : current(x) {}
  648.   RandomAccessIterator base() const { return current; }
  649.   Reference operator*() const { return *(current - 1); }
  650. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  651.   pointer operator->() const { return &(operator*()); }
  652. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  653.   self& operator++() {
  654.     --current;
  655.     return *this;
  656.   }
  657.   self operator++(int) {
  658.     self tmp = *this;
  659.     --current;
  660.     return tmp;
  661.   }
  662.   self& operator--() {
  663.     ++current;
  664.     return *this;
  665.   }
  666.   self operator--(int) {
  667.     self tmp = *this;
  668.     ++current;
  669.     return tmp;
  670.   }
  671.   self operator+(Distance n) const {
  672.     return self(current - n);
  673.   }
  674.   self& operator+=(Distance n) {
  675.     current -= n;
  676.     return *this;
  677.   }
  678.   self operator-(Distance n) const {
  679.     return self(current + n);
  680.   }
  681.   self& operator-=(Distance n) {
  682.     current += n;
  683.     return *this;
  684.   }
  685.   Reference operator[](Distance n) const { return *(*this + n); }
  686. };
  687.  
  688. template <class RandomAccessIterator, class T, class Reference, class Distance>
  689. inline random_access_iterator_tag
  690. iterator_category(const reverse_iterator<RandomAccessIterator, T,
  691.                                          Reference, Distance>&) {
  692.   return random_access_iterator_tag();
  693. }
  694.  
  695. template <class RandomAccessIterator, class T, class Reference, class Distance>
  696. inline T* value_type(const reverse_iterator<RandomAccessIterator, T,
  697.                                             Reference, Distance>&) {
  698.   return (T*) 0;
  699. }
  700.  
  701. template <class RandomAccessIterator, class T, class Reference, class Distance>
  702. inline Distance* distance_type(const reverse_iterator<RandomAccessIterator, T,
  703.                                                       Reference, Distance>&) {
  704.   return (Distance*) 0;
  705. }
  706.  
  707.  
  708. template <class RandomAccessIterator, class T, class Reference, class Distance>
  709. inline bool operator==(const reverse_iterator<RandomAccessIterator, T,
  710.                                               Reference, Distance>& x, 
  711.                        const reverse_iterator<RandomAccessIterator, T,
  712.                                               Reference, Distance>& y) {
  713.   return x.base() == y.base();
  714. }
  715.  
  716. template <class RandomAccessIterator, class T, class Reference, class Distance>
  717. inline bool operator<(const reverse_iterator<RandomAccessIterator, T,
  718.                                              Reference, Distance>& x, 
  719.                       const reverse_iterator<RandomAccessIterator, T,
  720.                                              Reference, Distance>& y) {
  721.   return y.base() < x.base();
  722. }
  723.  
  724. template <class RandomAccessIterator, class T, class Reference, class Distance>
  725. inline Distance operator-(const reverse_iterator<RandomAccessIterator, T,
  726.                                                  Reference, Distance>& x, 
  727.                           const reverse_iterator<RandomAccessIterator, T,
  728.                                                  Reference, Distance>& y) {
  729.   return y.base() - x.base();
  730. }
  731.  
  732. template <class RandomAccessIter, class T, class Ref, class Dist>
  733. inline reverse_iterator<RandomAccessIter, T, Ref, Dist> 
  734. operator+(Dist n, const reverse_iterator<RandomAccessIter, T, Ref, Dist>& x) {
  735.   return reverse_iterator<RandomAccessIter, T, Ref, Dist>(x.base() - n);
  736. }
  737.  
  738. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  739.  
  740. template <class T, class Distance = ptrdiff_t> 
  741. class istream_iterator {
  742.   friend bool
  743.   operator== __STL_NULL_TMPL_ARGS (const istream_iterator<T, Distance>& x,
  744.                                    const istream_iterator<T, Distance>& y);
  745. protected:
  746.   istream* stream;
  747.   T value;
  748.   bool end_marker;
  749.   void read() {
  750.     end_marker = (*stream) ? true : false;
  751.     if (end_marker) *stream >> value;
  752.     end_marker = (*stream) ? true : false;
  753.   }
  754. public:
  755.   typedef input_iterator_tag iterator_category;
  756.   typedef T                  value_type;
  757.   typedef Distance           difference_type;
  758.   typedef const T*           pointer;
  759.   typedef const T&           reference;
  760.  
  761.   istream_iterator() : stream(&cin), end_marker(false) {}
  762.   istream_iterator(istream& s) : stream(&s) { read(); }
  763.   reference operator*() const { return value; }
  764. #ifndef __SGI_STL_NO_ARROW_OPERATOR
  765.   pointer operator->() const { return &(operator*()); }
  766. #endif /* __SGI_STL_NO_ARROW_OPERATOR */
  767.   istream_iterator<T, Distance>& operator++() { 
  768.     read(); 
  769.     return *this;
  770.   }
  771.   istream_iterator<T, Distance> operator++(int)  {
  772.     istream_iterator<T, Distance> tmp = *this;
  773.     read();
  774.     return tmp;
  775.   }
  776. };
  777.  
  778. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  779.  
  780. template <class T, class Distance>
  781. inline input_iterator_tag 
  782. iterator_category(const istream_iterator<T, Distance>&) {
  783.   return input_iterator_tag();
  784. }
  785.  
  786. template <class T, class Distance>
  787. inline T* value_type(const istream_iterator<T, Distance>&) { return (T*) 0; }
  788.  
  789. template <class T, class Distance>
  790. inline Distance* distance_type(const istream_iterator<T, Distance>&) {
  791.   return (Distance*) 0;
  792. }
  793.  
  794. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  795.  
  796. template <class T, class Distance>
  797. inline bool operator==(const istream_iterator<T, Distance>& x,
  798.                        const istream_iterator<T, Distance>& y) {
  799.   return x.stream == y.stream && x.end_marker == y.end_marker ||
  800.          x.end_marker == false && y.end_marker == false;
  801. }
  802.  
  803. template <class T>
  804. class ostream_iterator {
  805. protected:
  806.   ostream* stream;
  807.   const char* string;
  808. public:
  809.   typedef output_iterator_tag iterator_category;
  810.   typedef void                value_type;
  811.   typedef void                difference_type;
  812.   typedef void                pointer;
  813.   typedef void                reference;
  814.  
  815.   ostream_iterator(ostream& s) : stream(&s), string(0) {}
  816.   ostream_iterator(ostream& s, const char* c) : stream(&s), string(c)  {}
  817.   ostream_iterator<T>& operator=(const T& value) { 
  818.     *stream << value;
  819.     if (string) *stream << string;
  820.     return *this;
  821.   }
  822.   ostream_iterator<T>& operator*() { return *this; }
  823.   ostream_iterator<T>& operator++() { return *this; } 
  824.   ostream_iterator<T>& operator++(int) { return *this; } 
  825. };
  826.  
  827. #ifndef __STL_CLASS_PARTIAL_SPECIALIZATION
  828.  
  829. template <class T>
  830. inline output_iterator_tag 
  831. iterator_category(const ostream_iterator<T>&) {
  832.   return output_iterator_tag();
  833. }
  834.  
  835. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  836.  
  837. __STL_END_NAMESPACE
  838.  
  839. #endif /* __SGI_STL_INTERNAL_ITERATOR_H */
  840.  
  841. // Local Variables:
  842. // mode:C++
  843. // End:
  844.